import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import 'package_info_service.dart';
import 'storage_service.dart';
import 'app_config_service.dart';
import 'dio_service.dart';
import 'permission_service.dart';
import 'user_service.dart';
import 'amap_location_service.dart';
import 'points_permission_service.dart';
import 'alipay_service.dart';
import 'rongcloud_service.dart';
import 'message_storage_service.dart';
import 'business_orchestration_service.dart';
import 'jpush_service.dart';
import '../routers/route_service.dart';
import '../utils/smart_notification_util.dart';
import '../utils/background_notification_helper.dart';

/// 服务定位器 - 统一管理所有GetX服务的注册和初始化
///
/// 🎯 服务初始化分阶段策略：
/// 1. 核心服务（用于读取隐私协议状态）
/// 2. 完整服务（用户同意隐私协议后初始化）
class ServiceLocator {
  /// 🔧 初始化核心服务（隐私协议弹窗前）
  ///
  /// 只初始化读取隐私协议状态所必需的最小服务
  static Future<void> initCoreServices() async {
    debugPrint('🔧 ============ 初始化核心服务 ============');

    try {
      // 1. 注册存储服务（基础设施层）- 必须最先初始化
      debugPrint('💾 注册存储服务...');
      Get.put<StorageService>(StorageService(), permanent: true);
      await Get.find<StorageService>().onInit();

      // 2. 注册应用配置服务（业务层，依赖存储服务）
      debugPrint('⚙️ 注册应用配置服务...');
      Get.put<AppConfigService>(AppConfigService(), permanent: true);
      await Get.find<AppConfigService>().onInit();

      debugPrint('✅ 核心服务初始化完成');
      debugPrint('=========================================');
    } catch (e) {
      debugPrint('❌ 核心服务初始化失败: $e');
      rethrow;
    }
  }

  /// 🚀 初始化完整服务（用户同意隐私协议后）
  ///
  /// 初始化应用运行所需的所有业务服务
  static Future<void> initFullServices() async {
    debugPrint('🚀 ============ 初始化完整服务 ============');

    try {
      // 1. 注册应用包信息服务（基础服务）
      debugPrint('📦 注册应用包信息服务...');
      if (!Get.isRegistered<PackageInfoService>()) {
        Get.put<PackageInfoService>(PackageInfoService(), permanent: true);
        await Get.find<PackageInfoService>().onInit();
      }

      // 2. 注册网络服务（基础设施层，依赖存储服务）
      debugPrint('🌐 注册网络服务...');
      if (!Get.isRegistered<DioService>()) {
        Get.put<DioService>(DioService(), permanent: true);
        await Get.find<DioService>().onInit();
      }

      // 3. 注册权限服务（基础设施层，系统权限管理）
      debugPrint('🔐 注册权限服务...');
      if (!Get.isRegistered<PermissionService>()) {
        Get.put<PermissionService>(PermissionService(), permanent: true);
        Get.find<PermissionService>().onInit();
      }

      // 4. 注册高德定位服务（基础设施层，位置服务）
      debugPrint('🗺️ 注册高德定位服务...');
      if (!Get.isRegistered<AmapLocationService>()) {
        Get.put<AmapLocationService>(AmapLocationService(), permanent: true);
        Get.find<AmapLocationService>().onInit();
      }

      // 5. 注册路由服务（基础设施层，路由管理）
      debugPrint('🧭 注册路由服务...');
      if (!Get.isRegistered<RouteService>()) {
        Get.put<RouteService>(RouteService(), permanent: true);
      }

      // 6. 注册用户服务（业务层，依赖存储服务和网络服务）
      debugPrint('👤 注册用户服务...');
      if (!Get.isRegistered<UserService>()) {
        Get.put<UserService>(UserService(), permanent: true);
        await Get.find<UserService>().onInit();
      }

      // 7. 注册积分权限服务（业务层，依赖用户服务和存储服务）
      debugPrint('💰 注册积分权限服务...');
      if (!Get.isRegistered<PointsPermissionService>()) {
        Get.put<PointsPermissionService>(
          PointsPermissionService(),
          permanent: true,
        );
        Get.find<PointsPermissionService>().onInit();
      }

      // 8. 注册支付宝服务（基础设施层，支付功能）
      debugPrint('💳 注册支付宝服务...');
      if (!Get.isRegistered<AlipayService>()) {
        final alipayService = AlipayService();
        Get.put<AlipayService>(alipayService, permanent: true);
        await alipayService.init();
      }

      // 9. 注册消息存储服务（基础设施层，消息本地存储和未读数管理）
      debugPrint('💾 注册消息存储服务...');
      if (!Get.isRegistered<MessageStorageService>()) {
        Get.put<MessageStorageService>(
          MessageStorageService(),
          permanent: true,
        );
        await Get.find<MessageStorageService>().onInit();
      }

      // 10. 注册业务编排服务（业务逻辑层，复杂业务流程编排）
      debugPrint('📬 注册业务编排服务...');
      if (!Get.isRegistered<BusinessOrchestrationService>()) {
        Get.put<BusinessOrchestrationService>(
          BusinessOrchestrationService(),
          permanent: true,
        );
      }

      // 11. 注册融云IM服务（基础设施层，即时通讯功能）
      debugPrint('💬 注册融云IM服务...');
      if (!Get.isRegistered<RongCloudService>()) {
        Get.put<RongCloudService>(RongCloudService(), permanent: true);
        // GetX会自动调用onInit，不需要手动await
      }

      // 12. 注册极光推送服务（基础设施层，后台消息推送）
      debugPrint('🔔 注册极光推送服务...');
      if (!Get.isRegistered<JPushService>()) {
        Get.put<JPushService>(JPushService(), permanent: true);
        // GetX会自动调用onInit，不需要手动await
      }

      // 13. 初始化智能通知工具（不注册为GetX服务，直接初始化单例）
      debugPrint('🔔 初始化智能通知工具...');
      await SmartNotificationUtil.instance.initialize();
      await BackgroundNotificationHelper.instance.initialize();

      debugPrint('✅ 完整服务初始化完成');

      // 打印服务注册状态（仅在调试模式下）
      if (kDebugMode) {
        _printServiceStatus();
      }

      debugPrint('=========================================');
    } catch (e) {
      debugPrint('❌ 完整服务初始化失败: $e');
      rethrow;
    }
  }

  /// 📦 初始化所有服务（向后兼容）
  ///
  /// 一次性初始化核心服务和完整服务
  /// ⚠️ 建议使用 initCoreServices() 和 initFullServices() 分阶段初始化
  @Deprecated('使用 initCoreServices() 和 initFullServices() 代替')
  static Future<void> init() async {
    debugPrint('🚀 开始初始化所有服务（向后兼容模式）...');

    try {
      // 先初始化核心服务
      await initCoreServices();

      // 再初始化完整服务
      await initFullServices();

      debugPrint('✅ 所有服务初始化完成（向后兼容模式）');
    } catch (e) {
      debugPrint('❌ 服务初始化失败（向后兼容模式）: $e');
      rethrow;
    }
  }

  // 服务便捷访问方法（可选，也可以直接使用 Get.find<T>()）
  static PackageInfoService get packageInfo => Get.find<PackageInfoService>();
  static StorageService get storage => Get.find<StorageService>();
  static AppConfigService get appConfig => Get.find<AppConfigService>();
  static DioService get network => Get.find<DioService>();
  static PermissionService get permission => Get.find<PermissionService>();
  static AmapLocationService get location => Get.find<AmapLocationService>();
  static RouteService get route => Get.find<RouteService>();
  static UserService get user => Get.find<UserService>();
  static PointsPermissionService get pointsPermission =>
      Get.find<PointsPermissionService>();
  static AlipayService get alipay => Get.find<AlipayService>();
  static MessageStorageService get messageStorage =>
      Get.find<MessageStorageService>();
  static BusinessOrchestrationService get orchestration =>
      Get.find<BusinessOrchestrationService>();
  static RongCloudService get rongCloud => Get.find<RongCloudService>();

  // TODO: 添加其他服务的获取方法
  // static DioService get network => Get.find<DioService>();
  // static UserService get user => Get.find<UserService>();
  // static ThemeService get theme => Get.find<ThemeService>();

  /// 检查服务是否已注册
  static bool isServiceRegistered<T>() {
    return Get.isRegistered<T>();
  }

  /// 获取服务统计信息
  static Map<String, dynamic> getServiceStats() {
    return {
      'registeredServices': [
        if (Get.isRegistered<PackageInfoService>()) 'PackageInfoService',
        if (Get.isRegistered<StorageService>()) 'StorageService',
        if (Get.isRegistered<AppConfigService>()) 'AppConfigService',
        if (Get.isRegistered<DioService>()) 'DioService',
        if (Get.isRegistered<PermissionService>()) 'PermissionService',
        if (Get.isRegistered<AmapLocationService>()) 'AmapLocationService',
        if (Get.isRegistered<RouteService>()) 'RouteService',
        if (Get.isRegistered<UserService>()) 'UserService',
        if (Get.isRegistered<PointsPermissionService>())
          'PointsPermissionService',
        if (Get.isRegistered<AlipayService>()) 'AlipayService',
        if (Get.isRegistered<MessageStorageService>()) 'MessageStorageService',
        if (Get.isRegistered<RongCloudService>()) 'RongCloudService',
        // TODO: 添加其他服务检查
        // if (Get.isRegistered<ThemeService>()) 'ThemeService',
      ],
      'totalServices': _getRegisteredServiceCount(),
      'initTime': DateTime.now().toIso8601String(),
    };
  }

  /// 获取已注册服务数量
  static int _getRegisteredServiceCount() {
    int count = 0;
    if (Get.isRegistered<PackageInfoService>()) count++;
    if (Get.isRegistered<StorageService>()) count++;
    if (Get.isRegistered<AppConfigService>()) count++;
    if (Get.isRegistered<DioService>()) count++;
    if (Get.isRegistered<PermissionService>()) count++;
    if (Get.isRegistered<AmapLocationService>()) count++;
    if (Get.isRegistered<RouteService>()) count++;
    if (Get.isRegistered<UserService>()) count++;
    if (Get.isRegistered<PointsPermissionService>()) count++;
    if (Get.isRegistered<AlipayService>()) count++;
    if (Get.isRegistered<MessageStorageService>()) count++;
    if (Get.isRegistered<RongCloudService>()) count++;
    // TODO: 添加其他服务计数
    // if (Get.isRegistered<ThemeService>()) count++;
    return count;
  }

  /// 打印服务注册状态（调试用）
  static void _printServiceStatus() {
    debugPrint('==================== 服务状态 ====================');

    // 检查应用包信息服务
    if (Get.isRegistered<PackageInfoService>()) {
      debugPrint('✅ PackageInfoService: 已注册');
    } else {
      debugPrint('❌ PackageInfoService: 未注册');
    }

    // 检查存储服务
    if (Get.isRegistered<StorageService>()) {
      debugPrint('✅ StorageService: 已注册');
    } else {
      debugPrint('❌ StorageService: 未注册');
    }

    // 检查应用配置服务
    if (Get.isRegistered<AppConfigService>()) {
      debugPrint('✅ AppConfigService: 已注册');
    } else {
      debugPrint('❌ AppConfigService: 未注册');
    }

    // 检查网络服务
    if (Get.isRegistered<DioService>()) {
      debugPrint('✅ DioService: 已注册');
    } else {
      debugPrint('❌ DioService: 未注册');
    }

    // 检查权限服务
    if (Get.isRegistered<PermissionService>()) {
      debugPrint('✅ PermissionService: 已注册');
    } else {
      debugPrint('❌ PermissionService: 未注册');
    }

    // 检查高德定位服务
    if (Get.isRegistered<AmapLocationService>()) {
      debugPrint('✅ AmapLocationService: 已注册');
    } else {
      debugPrint('❌ AmapLocationService: 未注册');
    }

    // 检查路由服务
    if (Get.isRegistered<RouteService>()) {
      debugPrint('✅ RouteService: 已注册');
    } else {
      debugPrint('❌ RouteService: 未注册');
    }

    // 检查用户服务
    if (Get.isRegistered<UserService>()) {
      debugPrint('✅ UserService: 已注册');
    } else {
      debugPrint('❌ UserService: 未注册');
    }

    // 检查积分权限服务
    if (Get.isRegistered<PointsPermissionService>()) {
      debugPrint('✅ PointsPermissionService: 已注册');
    } else {
      debugPrint('❌ PointsPermissionService: 未注册');
    }

    // 检查支付宝服务
    if (Get.isRegistered<AlipayService>()) {
      debugPrint('✅ AlipayService: 已注册');
    } else {
      debugPrint('❌ AlipayService: 未注册');
    }

    // 检查消息存储服务
    if (Get.isRegistered<MessageStorageService>()) {
      debugPrint('✅ MessageStorageService: 已注册');
    } else {
      debugPrint('❌ MessageStorageService: 未注册');
    }

    // 检查融云IM服务
    if (Get.isRegistered<RongCloudService>()) {
      debugPrint('✅ RongCloudService: 已注册');
    } else {
      debugPrint('❌ RongCloudService: 未注册');
    }

    // TODO: 检查其他服务

    debugPrint('总计: ${_getRegisteredServiceCount()} 个服务已注册');
    debugPrint('================================================');
  }

  /// 重新初始化服务（谨慎使用）
  static Future<void> reinit() async {
    debugPrint('🔄 重新初始化服务...');

    try {
      // 清理现有服务
      dispose();

      // 重新初始化
      await init();

      debugPrint('✅ 服务重新初始化完成');
    } catch (e) {
      debugPrint('❌ 服务重新初始化失败: $e');
      rethrow;
    }
  }

  /// 清理所有服务（应用退出时调用）
  static void dispose() {
    debugPrint('🧹 清理所有服务...');

    try {
      // 清理应用包信息服务
      if (Get.isRegistered<PackageInfoService>()) {
        Get.delete<PackageInfoService>();
        debugPrint('🧹 PackageInfoService 已清理');
      }

      // 清理存储服务
      if (Get.isRegistered<StorageService>()) {
        Get.delete<StorageService>();
        debugPrint('🧹 StorageService 已清理');
      }

      // 清理应用配置服务
      if (Get.isRegistered<AppConfigService>()) {
        Get.delete<AppConfigService>();
        debugPrint('🧹 AppConfigService 已清理');
      }

      // 清理网络服务
      if (Get.isRegistered<DioService>()) {
        Get.delete<DioService>();
        debugPrint('🧹 DioService 已清理');
      }

      // 清理权限服务
      if (Get.isRegistered<PermissionService>()) {
        Get.delete<PermissionService>();
        debugPrint('🧹 PermissionService 已清理');
      }

      // 清理高德定位服务
      if (Get.isRegistered<AmapLocationService>()) {
        Get.delete<AmapLocationService>();
        debugPrint('🧹 AmapLocationService 已清理');
      }

      // 清理路由服务
      if (Get.isRegistered<RouteService>()) {
        Get.delete<RouteService>();
        debugPrint('🧹 RouteService 已清理');
      }

      // 清理用户服务
      if (Get.isRegistered<UserService>()) {
        Get.delete<UserService>();
        debugPrint('🧹 UserService 已清理');
      }

      // 清理积分权限服务
      if (Get.isRegistered<PointsPermissionService>()) {
        Get.delete<PointsPermissionService>();
        debugPrint('🧹 PointsPermissionService 已清理');
      }

      // 清理支付宝服务
      if (Get.isRegistered<AlipayService>()) {
        Get.delete<AlipayService>();
        debugPrint('🧹 AlipayService 已清理');
      }

      // 清理消息存储服务
      if (Get.isRegistered<MessageStorageService>()) {
        Get.delete<MessageStorageService>();
        debugPrint('🧹 MessageStorageService 已清理');
      }

      // 清理融云IM服务
      if (Get.isRegistered<RongCloudService>()) {
        Get.delete<RongCloudService>();
        debugPrint('🧹 RongCloudService 已清理');
      }

      // TODO: 清理其他服务

      debugPrint('✅ 所有服务已清理');
    } catch (e) {
      debugPrint('❌ 服务清理失败: $e');
    }
  }
}
